/*
 bili_bili大_P王
 * */
#include <stdio.h>
#include <stdlib.h>

//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point)         //打印链表
{
    if(point!=NULL)
    {
        struct Node* head=point;
        do
        {
            printf("%d \n",point->data);
            point=point->next;
        }while(point!=head);
    }
    else
    {
        printf("List is NULL! \n");
    }
}

//添加节点，头部位置添加节点(因为是在链表头插入法，所以，写成添加)
void insertFromHead(struct Node** head,int data)
{
    //创建新节点   malloc和new非常像
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=newNode;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        //找到最后一个数据
        struct Node* point=*head;
        newNode->next=point;
        while(point->next!=(*head))
        {
            point=point->next;
        }
        point->next=newNode;
        *head=newNode;
    }
}

//添加节点，尾部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromBehind(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        struct Node* point=*head;
        while(point->next!=NULL)
        {
            point=point->next;
        }
        point->next=newNode;
    }
}

//动态链表删除节点
int deleteNode(struct Node** head,int data)
{
    struct Node* point=*head;
    if(point->data==data)                    //头结点就是要删除的数据data
    {
        *head=point->next;
        //释放内存
        free(point);
        return 1;
    }
    else                                     //头结点不是要删除的数据data
    {
        while(point->next!=NULL)
        {
            if(point->next->data==data)
            {
                struct Node* deleNode=point->next;
                point->next=point->next->next;
                free(deleNode);
                return 1;
            }
            point=point->next;
        }
        return 0;
    }
}

int main()
{
    struct Node* Head=NULL;
    insertFromHead(&Head,12);
    insertFromHead(&Head,122);
    insertFromHead(&Head,152);
    printList(Head);

    return 0;
}

/*
D:\code\clion\cplusList.exe
13
1234
1883
1243
deleteNode1: 1
 */





#if 0

/****09 动态链表 删除节点2*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printReList(struct Node* point);         //递归打印链表

//添加节点，头部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromHead(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        newNode->next=*head;
        *head=newNode;
    }
}

//添加节点，尾部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromBehind(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        struct Node* point=*head;
        while(point->next!=NULL)
        {
            point=point->next;
        }
        point->next=newNode;
    }
}

//动态链表删除节点
int deleteNode(struct Node** head,int data)
{
    struct Node* point=*head;
    if(point->data==data)                    //头结点就是要删除的数据data
    {
        *head=point->next;
        //释放内存
        free(point);
        return 1;
    }
    else                                     //头结点不是要删除的数据data
    {
        while(point->next!=NULL)
        {
            if(point->next->data==data)
            {
                struct Node* deleNode=point->next;
                point->next=point->next->next;
                free(deleNode);
                return 1;
            }
            point=point->next;
        }
        return 0;
    }
}

int main()
{
    struct Node* Head=NULL;
    addFromBehind(&Head,123);
    addFromBehind(&Head,13);
    addFromBehind(&Head,1234);
    addFromBehind(&Head,17893);
    addFromBehind(&Head,1883);
    addFromBehind(&Head,1243);
    int deleteNode1=deleteNode(&Head,123);
    deleteNode(&Head,17893);

    printReList(Head);

    printf("deleteNode1: %d\n",deleteNode1);

    return 0;
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

/*
D:\code\clion\cplusList.exe
13
1234
1883
1243
deleteNode1: 1
 */

#endif





#if 0

/****09 动态链表 删除节点1*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printReList(struct Node* point);         //递归打印链表

//添加节点，头部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromHead(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        newNode->next=*head;
        *head=newNode;
    }
}

//添加节点，尾部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromBehind(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        struct Node* point=*head;
        while(point->next!=NULL)
        {
            point=point->next;
        }
        point->next=newNode;
    }
}

//动态链表删除节点
struct Node* deleteNode(struct Node** head,int data)
{
    struct Node* point=*head;
    if(point->data==data)
    {
        *head=point->next;
        //释放内存
        free(point);
        return point;
    }
}

int main()
{
    struct Node* Head=NULL;
    addFromBehind(&Head,123);
    addFromBehind(&Head,13);
    addFromBehind(&Head,1234);
    struct Node* point=deleteNode(&Head,123);

    printReList(Head);

    printf("point->data: %d\n",point->data);

    return 0;
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}
/*
D:\code\clion\cplusList.exe
13
1234
point->data: 7350160
 */

#endif





#if 0

/****09 动态链表*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printReList(struct Node* point);         //递归打印链表

//添加节点，头部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromHead(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        newNode->next=*head;
        *head=newNode;
    }
}

//添加节点，尾部位置添加节点(因为是在链表头插入法，所以，写成添加)
void addFromBehind(struct Node** head,int data)
{
    //创建新节点
    struct Node* newNode=(struct Ndoe*)malloc(sizeof(struct Node));
    newNode->data=data;
    newNode->next=NULL;
    if(*head==NULL)
    {
        *head=newNode;
    }
    else
    {
        struct Node* point=*head;
        while(point->next!=NULL)
        {
            point=point->next;
        }
        point->next=newNode;
    }
}

int main()
{
    struct Node* Head=NULL;
    addFromBehind(&Head,123);
    addFromBehind(&Head,13);
    addFromBehind(&Head,1234);
    printReList(Head);

    return 0;
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

/*
D:\code\clion\cplusList.exe
123
13
1234
 */

#endif





#if 0

/****08 删除和查找节点*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point);           //循环打印链表
void printReList(struct Node* point);         //递归打印链表
int getListNodeNumber(struct Node* point);    //计算链表节点个数
int insertLinkListBehind(struct Node** head,int data,struct Node* newNode);    //后插法:  data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
//前插法  需要加一个预判
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListFront(struct Node** head,int data,struct Node* newNode);
//删除链表head中的数据data
int deleteLinkListFront(struct Node** head,int data);
//查找节点   c语言中是没有bool类型的，所以，只能用int去表示
int searchLink(struct Node* point,int data){
    while(point!=NULL){
        if(point->data==data){
            return 1;
        }
        point=point->next;
    }
    return 0;
}


int main(){
    struct Node node1={11,NULL};
    struct Node node2={22,NULL};
    struct Node node3={33,NULL};
    struct Node node4={44,NULL};

    struct Node* head=&node1;                                 //头结点的指针
    insertLinkListFront(&head,11,&node2);
    insertLinkListBehind(&head,11,&node3);
    insertLinkListFront(&head,11,&node4);

    deleteLinkListFront(&head,22);

    printList(head);
    if(searchLink(head,11)){
        printf("数据存在！\n");
    }else{
        printf("数据不存在！\n");
    }

    return 0;
}

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}

//后插法
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListBehind(struct Node** head,int data,struct Node* newNode){
    struct Node* point=*head;
    while(point!=NULL){
        if(point->data==data){
            newNode->next=point->next;
            point->next=newNode;
            return 1;                 //插入成功
        }
        //point偏移
        point=point->next;
    }
    return 0;                          //插入失败
}

//前插法  需要加一个预判
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListFront(struct Node** head,int data,struct Node* newNode){
    struct Node* point=*head;
    if(point->data==data){                                            //要插入的地方是头结点
        //新节点的指向
        newNode->next=point;                                          //在头结点前插入数据
        //头地址重新指向新节点
        *head=newNode;
        return 1;
    }else{
        while(point->next!=NULL){                                     //需要加一个预判
            if(point->next->data==data){
                newNode->next=point->next;
                point->next=newNode;
                return 1;                 //插入成功
            }
            //point偏移
            point=point->next;
        }
    }
    return 0;                          //插入失败
}

//删除链表head中的数据data
int deleteLinkListFront(struct Node** head,int data){
    struct Node* point=*head;
    if(point->data==data){                                            //要插入的地方是头结点
        *head=point->next;
        return 1;
    }else{
        while(point->next!=NULL){                                     //需要加一个预判
            if(point->next->data==data){
                point->next=point->next->next;
                return 1;                 //插入成功
            }
            //point偏移
            point=point->next;
        }
    }
    return 0;                          //插入失败
}
/*
D:\code\clion\cplusList.exe
44
11
33
数据存在！
 * */

#endif





#if 0

/****07 前插法2*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point);           //循环打印链表
void printReList(struct Node* point);         //递归打印链表
int getListNodeNumber(struct Node* point);    //计算链表节点个数
int insertLinkListBehind(struct Node** head,int data,struct Node* newNode);    //后插法:  data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））

//前插法  需要加一个预判
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListFront(struct Node** head,int data,struct Node* newNode){
    struct Node* point=*head;
    if(point->data==data){                                            //要插入的地方是头结点
        //新节点的指向
        newNode->next=point;                                          //在头结点前插入数据
        //头地址重新指向新节点
        *head=newNode;
        return 1;
    }else{
        while(point->next!=NULL){                                     //需要加一个预判
            if(point->next->data==data){
                newNode->next=point->next;
                point->next=newNode;
                return 1;                 //插入成功
            }
            //point偏移
            point=point->next;
        }
    }
    return 0;                          //插入失败
}


int main(){
    struct Node node1={11,NULL};
    struct Node node2={22,NULL};
    struct Node node3={33,NULL};
    struct Node node4={44,NULL};

    struct Node* head=&node1;                                 //头结点的指针
    insertLinkListFront(&head,11,&node2);
    insertLinkListBehind(&head,11,&node3);
    insertLinkListFront(&head,11,&node4);
    printList(head);

    return 0;
}

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}

//后插法
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListBehind(struct Node** head,int data,struct Node* newNode){
    struct Node* point=*head;
    while(point!=NULL){
        if(point->data==data){
            newNode->next=point->next;
            point->next=newNode;
            return 1;                 //插入成功
        }
        //point偏移
        point=point->next;
    }
    return 0;                          //插入失败
}

/*
D:\code\clion\cplusList.exe
22
44
11
33
 * */

#endif







#if 0

/****07 前插法1*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point);           //循环打印链表
void printReList(struct Node* point);         //递归打印链表
int getListNodeNumber(struct Node* point);    //计算链表节点个数
int insertLinkListBehind(struct Node* point,int data,struct Node* newNode);    //后插法:  data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））

//前插法  需要加一个预判
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListFront(struct Node** head,int data,struct Node* newNode){
    struct Node* point=*head;
    if(point->data==data){                                            //要插入的地方是头结点
        //新节点的指向
        newNode->next=point;                                          //在头结点前插入数据
        //头地址重新指向新节点
        *head=newNode;
        return 1;
    }else{
        while(point->next!=NULL){                                     //需要加一个预判
            if(point->next->data==data){
                newNode->next=point->next;
                point->next=newNode;
                return 1;                 //插入成功
            }
            //point偏移
            point=point->next;
        }
    }
    return 0;                          //插入失败
}


int main(){
    struct Node node1={11,NULL};
    struct Node node2={22,NULL};
    struct Node node3={33,NULL};
    struct Node node4={44,NULL};

    struct Node* head=&node1;                                 //头结点的指针
    insertLinkListFront(&head,11,&node2);
    insertLinkListFront(&head,11,&node3);
    insertLinkListFront(&head,11,&node4);
    printList(head);

    return 0;
}

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}

//后插法
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListBehind(struct Node* point,int data,struct Node* newNode){
    while(point!=NULL){
        if(point->data==data){
            newNode->next=point->next;
            point->next=newNode;
            return 1;                 //插入成功
        }
        //point偏移
        point=point->next;
    }
    return 0;                          //插入失败
}

#endif






#if 0

/****06 后插法补充*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point);           //循环打印链表
void printReList(struct Node* point);         //递归打印链表
int getListNodeNumber(struct Node* point);    //计算链表节点个数

//后插法
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListBehind(struct Node* point,int data,struct Node* newNode){
    while(point!=NULL){
        if(point->data==data){
            newNode->next=point->next;
            point->next=newNode;
            return 1;                 //插入成功
        }
        //point偏移
        point=point->next;
    }
    return 0;                          //插入失败
}

int main(){
    struct Node node1={11,NULL};
    struct Node node2={22,NULL};
    struct Node node3={33,NULL};
    struct Node node4={44,NULL};

    struct Node head={0,NULL};
    insertLinkListBehind(&head,0,&node1);
    insertLinkListBehind(&head,0,&node2);
//    insertLinkListBehind(&head,0,&node2);             //会导致node2指向自身，所以会循环输出22
    printList(&head);

//    struct Node* point=&node01;
//    printList(point);
//    printList(&node01);
    printf("链表的数量：%d\n", getListNodeNumber(&node1));   //1
    printf("链表的数量：%d\n", getListNodeNumber(&head));    //4    链表操作传入的是头结点，不能是别的节点
    printReList(&node1);

    return 0;
}

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}


#endif






#if 0

/****05 后插法*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

void printList(struct Node* point);           //循环打印链表
void printReList(struct Node* point);         //递归打印链表
int getListNodeNumber(struct Node* point);    //计算链表节点个数

//后插法
//data是插入的位置，newNode是插入的节点（因为后插法要改变指针指向，所以是指针（struct Node* newNode），而不是数据（struct Node newNode））
int insertLinkListBehind(struct Node* point,int data,struct Node* newNode){
    while(point!=NULL){
        if(point->data==data){
            newNode->next=point->next;
            point->next=newNode;
            return 1;                 //插入成功
        }
        //point偏移
        point=point->next;
    }
    return 0;                          //插入失败
}

int main(){
    struct Node node1={22,NULL};
    struct Node node2={33,NULL};
    struct Node node3={44,NULL};
    struct Node node4={55,NULL};
    struct Node node5={66,NULL};

    struct Node head={11,NULL};
    insertLinkListBehind(&head,11,&node1);
    insertLinkListBehind(&head,11,&node4);
    insertLinkListBehind(&head,55,&node5);
    printList(&head);

//    struct Node* point=&node01;
//    printList(point);
//    printList(&node01);
    printf("链表的数量：%d\n", getListNodeNumber(&node1));   //1
    printf("链表的数量：%d\n", getListNodeNumber(&head));    //4    链表操作传入的是头结点，不能是别的节点
    printReList(&node1);

    return 0;
}

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}

#endif








#if 0

/****04 计算节点数量*****/
//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

//计算链表节点数量
int getListNodeNumber(struct Node* point){  //函数中操作的是point,不是操作主函数 printf("链表的数量：%d\n", getListNodeNumber(&node01));调用的node01,所以，不会对node01产生任何影响
    int count=0;
    while(point!=NULL){
        count++;
        //point偏移
        point=point->next;
    }
    return count;
}

int main(){
    struct Node node01={11,NULL};
    struct Node node02={22,NULL};
    struct Node node03={33,NULL};
    struct Node node04={44,NULL};
    struct Node node05={55,NULL};
    node01.next=&node02;
    node02.next=&node03;
    node03.next=&node04;
    node04.next=&node05;

//    struct Node* point=&node01;
//    printList(point);
//    printList(&node01);
    printf("链表的数量：%d\n", getListNodeNumber(&node01));
    printReList(&node01);

    return 0;
}

#endif








#if 0

//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

//循环遍历写法
void printList(struct Node* point){
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
}

//递归遍历链表  建议用循环，递归有一点小问题
void printReList(struct Node* point){
    if(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point 偏移
        point=point->next;
        //再次重新调用函数本身
        printReList(point);
    }
}

int main(){
    struct Node node01={11,NULL};
    struct Node node02={22,NULL};
    struct Node node03={33,NULL};
    struct Node node04={44,NULL};
    node01.next=&node02;
    node02.next=&node03;
    node03.next=&node04;

//    struct Node* point=&node01;
//    printList(point);
//    printList(&node01);
    printReList(&node01);

    return 0;
}
/*
输出：
D:\code\clion\cplusList.exe
11
22
33
44
 * */

#endif





#if 0

//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

int main(){
    struct Node node01={11,NULL};
    struct Node node02={22,NULL};
    struct Node node03={33,NULL};
    struct Node node04={44,NULL};
    node01.next=&node02;
    node02.next=&node03;
    node03.next=&node04;

    struct Node* point=&node01;
    while(point!=NULL){
        //读数据
        printf("%d\n",point->data);
        //point偏移
        point=point->next;
    }
    return 0;
}

#endif




#if 0

//定义一个节点（藏宝箱）   链表比顺序表难，因为牵扯到结构体和结构体指针的问题
struct Node
{
    int data;
    //struct Node* 保存下一个节点的地址；
    struct Node* next;
};

int main(){
    struct Node node01={11,NULL};
    struct Node node02={22,NULL};
    struct Node node03={33,NULL};
    node01.next=&node02;
    node02.next=&node03;

    printf("%d\n",node01.data);
    //运算符优先级；
//    printf("%d\n",(*(node01.next)).data);
    printf("%d\n",node01.next->data);
    printf("%d\n",node01.next->next->data);

    return 0;
}
/*输出：
 D:\code\clion\cplusList.exe
11
22
33
 * */
#endif

/*
1. . 操作符
使用场景：当你有一个 结构体变量 时，使用 . 来访问该结构体的成员。
语法：struct_variable.member


 2. -> 操作符
使用场景：当你有一个指向 结构体的指针 时，使用 -> 来访问该结构体的成员。
语法：struct_pointer->member

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p = {10, 20}; // 结构体变量
    struct Point *pPtr = &p;   // 指向结构体的指针

    // 使用 -> 访问结构体指针的成员
    printf("x: %d, y: %d\n", pPtr->x, pPtr->y);

    // 等同于：
    printf("x: %d, y: %d\n", (*pPtr).x, (*pPtr).y);

    return 0;
}
 * */